import pandas as pd
import numpy as np
import warnings
from IPython.display import HTML

warnings.filterwarnings("ignore")
pd.set_option('display.max_columns', None)
pd.options.display.float_format = '{:,.2f}'.format

#Importation du fichier population.csv
population = pd.read_csv('src/main/datasets/population.csv')

#Importation du fichier dispo_alimentaire.csv
dispo_alimentaire = pd.read_csv('src/main/datasets/dispo_alimentaire.csv')

#Importation du fichier aide_alimentaire.csv
aide_alimentaire = pd.read_csv('src/main/datasets/aide_alimentaire.csv')

#Importation du fichier sous_nutrition.csv
sous_nutrition = pd.read_csv('src/main/datasets/sous_nutrition.csv')

#Afficher les dimensions du dataset
print("Le tableau comporte {} observation(s) ou article(s)".format(population.shape[0]))
print("Le tableau comporte {} colonne(s)".format(population.shape[1]))

#Consulter le nombre de colonnes
print("Le tableau comporte {} colonne(s)".format(population.shape[1]))
#La nature des données dans chacune des colonnes
print(population.dtypes)
#Le nombre de valeurs présentes dans chacune des colonnes
print(population.count())

#Affichage les 5 premières lignes de la table
population.head()

#Nous allons harmoniser les unités. Pour cela, nous avons décidé de multiplier la population par 1000
#Multiplication de la colonne valeur par 1000
population['Valeur'] = population['Valeur']*1000

#changement du nom de la colonne Valeur par Population
population = population.rename(columns={'Valeur': 'Population'})

#Affichage les 5 premières lignes de la table pour voir les modifications
population.head()

#Afficher les dimensions du dataset
print("Le tableau comporte {} observation(s) ou article(s)".format(dispo_alimentaire.shape[0]))

#Consulter le nombre de colonnes
print("Le tableau comporte {} colonne(s)".format(dispo_alimentaire.shape[1]))

dispo_alimentaire.dtypes

#Affichage les 5 premières lignes de la table
dispo_alimentaire.head()

#remplacement des NaN dans le dataset par des 0
dispo_alimentaire = dispo_alimentaire.fillna(0)

# multiplication de toutes les lignes contenant des milliers de tonnes en Kg
milliers_tonnes_col = [
    "Aliments pour animaux",
    "Autres Utilisations",
    "Disponibilité intérieure",
    "Exportations - Quantité",
    "Importations - Quantité",
    "Nourriture",
    "Pertes",
    "Production",
    "Semences",
    "Traitement",
    "Variation de stock",
]

dispo_alimentaire[milliers_tonnes_col] = dispo_alimentaire[milliers_tonnes_col].apply(lambda x: x*1_000_000)

#Affichage les 5 premières lignes de la table
dispo_alimentaire.head()

#Afficher les dimensions du dataset
print("Le tableau comporte {} observation(s) ou article(s)".format(aide_alimentaire.shape[0]))

#Consulter le nombre de colonnes
print("Le tableau comporte {} colonne(s)".format(aide_alimentaire.shape[1]))

aide_alimentaire.dtypes

#Affichage les 5 premières lignes de la table
aide_alimentaire.head().style.format({'Valeur': "{:,}"})

#changement du nom de la colonne Pays bénéficiaire par Zone
aide_alimentaire = aide_alimentaire.rename(columns={'Pays bénéficiaire': 'Zone'})

#Multiplication de la colonne Aide_alimentaire qui contient des tonnes par 1000 pour avoir des kg
aide_alimentaire['Valeur'] = aide_alimentaire['Valeur']*1000

#Affichage les 5 premières lignes de la table
aide_alimentaire.head().style.format({'Valeur': "{:,}"})

#Afficher les dimensions du dataset
print("Le tableau comporte {} observation(s) ou article(s)".format(sous_nutrition.shape[0]))

#Consulter le nombre de colonnes
print("Le tableau comporte {} colonne(s)".format(sous_nutrition.shape[1]))

#Afficher les 5 premières lignes de la table
sous_nutrition.head()

#Conversion de la colonne (avec l'argument errors=coerce qui permet de convertir automatiquement les lignes qui ne sont pas des nombres en NaN)
#Puis remplacement des NaN en 0
sous_nutrition['Valeur'] = pd.to_numeric(sous_nutrition['Valeur'], errors='coerce')

#changement du nom de la colonne Valeur par sous_nutrition
sous_nutrition = sous_nutrition.rename(columns={'Valeur': 'Sous_nutrition'})

#Multiplication de la colonne sous_nutrition par 1000000
sous_nutrition['Sous_nutrition'] = sous_nutrition['Sous_nutrition']*1_000_000

#Afficher les 5 premières lignes de la table
sous_nutrition.head()

sous_nutrition['Année'].unique()

# Il faut tout d'abord faire une jointure entre la table population et la table sous nutrition, en ciblant l'année 2017
#Jointure entre la table population et la table sous_nutrition
sous_nutrition_2017 = sous_nutrition[sous_nutrition['Année'] == '2016-2018']
population_2017 = population[population['Année'] == 2017]

population_sous_nutrition = pd.merge(population_2017, sous_nutrition_2017, on=['Zone'], how='inner').drop(columns=['Année_x', 'Année_y'])

#Affichage du dataset
population_sous_nutrition.head()

#Calcul et affichage du nombre de personnes en état de sous nutrition
total_pop_2017 = np.round(population_sous_nutrition["Population"].sum())
print("{:.2} billion".format(total_pop_2017/1_000_000_000))

total_sous_nutri_2017 = np.round(population_sous_nutrition["Sous_nutrition"].sum())
print("{:} million".format(total_sous_nutri_2017/1_000_000))

total_sous_nutri_2017/total_pop_2017*100

import plotly.express as px

# import plotly.graph_objects as go

# Calculate the sum of 'Population' and 'Sous_nutrition'
df_sum = population_sous_nutrition[["Population", "Sous_nutrition"]].sum()

# Calculate the rates
sous_nutrition_rate = df_sum["Sous_nutrition"] / df_sum["Population"] * 100
sufficient_nutrition_rate = 100 - sous_nutrition_rate

# Create a new DataFrame for the pie chart
df_pie = pd.DataFrame(
    {
        "Nutrition": ["Undernourished", "Sufficient"],
        "Rate": [sous_nutrition_rate, sufficient_nutrition_rate],
    }
)

# Create the pie chart
fig = px.pie(
    df_pie,
    values="Rate",
    names="Nutrition",
    title="Nutrition Status in 2017",
    hole=0.3,
    color_discrete_sequence=["blue", "red"],
)
fig.update_traces(textinfo="percent+label", pull=[0.1, 0], rotation=100)
fig.update_layout(
    width=800,
    height=600,
    annotations=[dict(text="Total Pop:<br> 7.5 Billion", showarrow=False)],
    showlegend=False,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white"),
)

fig.show()
fig.write_image("src/main/extracted_data/1.svg")

#Combien mange en moyenne un être humain ? Source => 
#https://news.yahoo.com/much-humans-eat-numerical-breakdown-181300224.html?guccounter=1&guce_referrer=aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8&guce_referrer_sig=AQAAALuJLrq4oPbwdPeKjMaGFqf8V-FPJbitkK6vIelD5UPvwQ1cx49nEXskW0-rkspJQHGFC61zncCC1Wa9yWOxEQMA01AEMa5OBdqXXInw25U7ZLMb9LsnU5nyBd1en8dvibMuDWEVtE_c2XghW-x_OwFjpSFgxQQTXFARYQDlWNPI

#On commence par faire une jointure entre le data frame population et Dispo_alimentaire afin d'ajouter dans ce dernier la population
#de chaque pays
population_2017 = population[population['Année'] == 2017]
dispo_alimentaire = pd.merge(dispo_alimentaire, population_2017[['Zone', 'Population']], on='Zone')

#Affichage du nouveau dataframe
dispo_alimentaire.head()

# Calcul du nombre d'humains pouvant être nourris
dispo_alimentaire["Disponibilité alimentaire en million (Kcal/jour)"] = np.round(
    (
        dispo_alimentaire["Disponibilité alimentaire (Kcal/personne/jour)"]
        * dispo_alimentaire["Population"]
    ),
    2,
)
total_dispo_alimentaire = np.round(
    dispo_alimentaire["Disponibilité alimentaire en million (Kcal/jour)"].sum()
)
humain_pouvant_nourris = total_dispo_alimentaire / 2250
print("{:.2} billion".format(humain_pouvant_nourris / 1_000_000_000))

humain_pouvant_nourris/total_pop_2017*100

import plotly.graph_objects as go

# Data
population = population_2017["Population"].sum()
capacity = humain_pouvant_nourris
population_percent = 100
capacity_percent = capacity / population * 100

# Create a bar chart using Plotly
fig = go.Figure(
    data=[
        go.Bar(
            name="Population",
            x=["Population"],
            y=[population],
            marker_color="blue",
            text=[f"{population_percent:.0f}%"],
            textposition="outside",
        ),
        go.Bar(
            name="Capacité d'alimentation",
            x=["Capacité d'alimentation"],
            y=[capacity],
            marker_color="green",
            text=[f"{capacity_percent:.0f}%"],
            textposition="outside",
        ),
    ]
)

# Update the layout
fig.update_layout(
    title="Population vs Capacité d'alimentation",
    yaxis_title="Population",
    barmode="group",
    showlegend=False,
    width=800,
    height=600,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
    annotations=[
        dict(
            x="Population",
            y=population / 2,
            text=f"{population/1_000_000_000:.1f} Billion",
            showarrow=False,
            font=dict(color="white", size=30),
            xanchor="center",
            yanchor="middle"
        ),
        dict(
            x="Capacité d'alimentation",
            y=population / 2,
            text=f"{capacity/1_000_000_000:.1f} Billion",
            showarrow=False,
            font=dict(color="white", size=30),
            xanchor="center",
            yanchor="middle"
        )
    ]
)

# Show the figure
fig.show()
fig.write_image("src/main/extracted_data/2.svg")

#Transfert des données avec les végétaux dans un nouveau dataframe
dispo_alimentaire_vegetaux = dispo_alimentaire[dispo_alimentaire['Origine'] == 'vegetale']

# Calcul du nombre de kcal disponible pour les végétaux
dispo_alimentaire_vegetaux["dispo_kcal"] = np.round(
    (
        dispo_alimentaire_vegetaux["Disponibilité alimentaire (Kcal/personne/jour)"]
        * dispo_alimentaire_vegetaux["Population"]
    ),
    2,
)
total_dispo_alimentaire_vegetaux = np.round(
    dispo_alimentaire_vegetaux["dispo_kcal"].sum()
)
print("{:,.2f} billion kcal".format(total_dispo_alimentaire_vegetaux / 1_000_000_000))

# Calcul du nombre d'humains pouvant être nourris avec les végétaux
humain_pouvant_nourris_vegetaux = total_dispo_alimentaire_vegetaux / 2250
print("{:.2f} billion".format(humain_pouvant_nourris_vegetaux / 1_000_000_000))

humain_pouvant_nourris_vegetaux/total_pop_2017*100

# Data
population = population_2017["Population"].sum()
capacity = humain_pouvant_nourris_vegetaux
population_percent = 100
capacity_percent = capacity / population * 100

# Create a bar chart using Plotly
fig = go.Figure(
    data=[
        go.Bar(
            name="Population",
            x=["Population"],
            y=[population],
            marker_color="blue",
            text=[f"{population_percent:.0f}%"],
            textposition="outside",
        ),
        go.Bar(
            name="Capacity",
            x=["Capacity"],
            y=[capacity],
            marker_color="green",
            text=[f"{capacity_percent:.0f}%"],
            textposition="outside",
        ),
    ]
)

# Update the layout
fig.update_layout(
    title="Population vs Feeding Capacity by Vegetal Products",
    yaxis_title="Population",
    barmode="group",
    showlegend=False,
    width=800,
    height=600,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# Add annotations one by one
fig.add_annotation(
    x="Population",
    y=population / 2,
    text=f"{population/1_000_000_000:.1f} Billion",
    showarrow=False,
    font=dict(color="white", size=30),
)

fig.add_annotation(
    x="Capacity",
    y=population / 2,
    text=f"{capacity/1_000_000_000:.1f} Billion",
    showarrow=False,
    font=dict(color="white", size=30),
)

# Show the figure
fig.show()
fig.write_image("src/main/extracted_data/3.svg")

#Calcul de la disponibilité totale
dispo_alimentaire_total = dispo_alimentaire["Disponibilité intérieure"].sum()
print("{:,.2f} million".format(dispo_alimentaire_total/1_000_000))

# création d'une boucle for pour afficher les différentes valeurs en fonction des colonnes aliments pour animaux, pertes, nourritures,
columns = ["Aliments pour animaux", "Pertes", "Nourriture", "Semences", "Traitement", "Autres Utilisations"]

for col in columns:
    dispo_alimentaire[col].fillna(0, inplace=True)
    dispo_alimentaire_sum = dispo_alimentaire[col].sum()
    dispo_alimentaire_proportion = dispo_alimentaire_sum / dispo_alimentaire_total
    print(f"{col} proportion is {dispo_alimentaire_proportion*100:.2f}%")

columns

df_sum = []
columns = [
    "Aliments pour animaux",
    "Pertes",
    "Nourriture",
    "Semences",
    "Traitement",
    "Autres Utilisations",
]

# Calculate the sum for each column and store it in the list
for col in columns:
    dispo_alimentaire[col].fillna(0, inplace=True)
    dispo_alimentaire_sum = dispo_alimentaire[col].sum()
    df_sum.append(dispo_alimentaire_sum)

# Create the pie chart
fig = px.pie(
    values=df_sum,
    names=columns,
    title="Breakdown of food availability in 2017",
    hole=0.3,
    color_discrete_sequence=["blue", "red", "yellow", "rgb(163,163,163)", "rgb(187,187,187)", "rgb(204,204,204)"],
)
fig.update_traces(textinfo="percent+label")
fig.update_layout(
    width=800,
    height=600,
    annotations=[
        dict(
            text=f"Total Dispo Ali:<br> {dispo_alimentaire_total/1_000_000_000:,.0f} Billion",
            showarrow=False,
        )
    ],
    showlegend=False,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=12),
)

fig.show()
fig.write_image("src/main/extracted_data/4.svg")

dispo_alimentaire["Produit"].unique()

# Création d'une liste avec toutes les variables
cereales = [
    "Blé",
    "Riz (Eq Blanchi)",
    "Orge",
    "Maïs",
    "Millet",
    "Seigle",
    "Avoine",
    "Sorgho",
    "Céréales, Autres"
]

#Création d'un dataframe avec les informations uniquement pour ces céréales
dispo_alimentaire_cereales = dispo_alimentaire[dispo_alimentaire['Produit'].isin(cereales)]
dispo_alimentaire_cereales.head()

dispo_alimentaire_cereales["Produit"].unique()

#Affichage de la proportion d'alimentation animale
dispo_alimentaire_cereales['Aliments pour animaux'].fillna(0, inplace=True)
dispo_alimentaire_cereal_total = dispo_alimentaire_cereales['Disponibilité intérieure'].sum()
dispo_alimentaire_cereales_animaux = dispo_alimentaire_cereales['Aliments pour animaux'].sum()
print("{:.2f} billion".format(dispo_alimentaire_cereales_animaux / 1_000_000_000))

#Affichage de la proportion d'alimentation animale
print(f"Aliments pour animaux proportion is {dispo_alimentaire_cereales_animaux/dispo_alimentaire_cereal_total*100:.2f}%")

dispo_alimentaire_celreales_nurriture = dispo_alimentaire_cereales["Nourriture"].sum()
print("{:.2f} billion".format(dispo_alimentaire_celreales_nurriture / 1_000_000_000))

print(f"Aliments pour nourriture is {dispo_alimentaire_celreales_nurriture/dispo_alimentaire_cereal_total*100:.2f}%")

# Calculate the proportions
nourriture_prop = dispo_alimentaire_celreales_nurriture / dispo_alimentaire_cereal_total
animaux_prop = dispo_alimentaire_cereales_animaux / dispo_alimentaire_cereal_total
others = 1 - nourriture_prop - animaux_prop

# Create the data for the pie chart
values = [nourriture_prop, animaux_prop, others]
labels = ["Aliments pour nourriture", "Aliments pour animaux", "Others"]

# Create the pie chart using Plotly
fig = px.pie(values=values, names=labels, title="Breakdown of Cereal Usage", hole=0.3, color_discrete_sequence=["blue", "red", "gray"])
fig.update_traces(textinfo="percent+label", rotation=100)
fig.update_layout(
    width=800,
    height=600,
    annotations=[
        dict(
            text=f"Total Dispo Cereal:<br> {dispo_alimentaire_cereal_total/1_000_000_000:,.0f} Billion",
            showarrow=False,
        )
    ],
    showlegend=False,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=12),
)

# Show the figure
fig.show()
fig.write_image("src/main/extracted_data/5.svg")

population_sous_nutrition

# Pays avec la proportion de personnes sous-alimentée la plus forte en 2017
#Création de la colonne proportion par pays
population_sous_nutrition['Proportion'] = (population_sous_nutrition['Sous_nutrition']/population_sous_nutrition['Population'])*100

#affichage après trie des 10 pires pays
population_sous_nutrition.sort_values(by='Proportion', ascending=False).head(10)

# Sort the data and select the top 10 countries
top_10_countries = population_sous_nutrition.sort_values(
    by="Proportion", ascending=False
).head(10)

# Create the bar chart using Plotly
fig = px.bar(
    top_10_countries,
    x="Proportion",
    y="Zone",
    orientation="h",
    title="Top 10 Countries with Highest Percentage of Undernourished Population in 2017",
    labels={"Proportion": "Percentage(%)", "Zone": ""},
    color="Proportion",
    color_continuous_scale="reds",
    # color_continuous_scale=["rgb(0,0,255)", "rgb(255,0,0)"],
    text=f"Proportion",
)

# Update the layout to invert the y-axis
fig.update_layout(
    width=1200,
    height=500,
    yaxis=dict(autorange="reversed"),
    coloraxis_showscale=False,
    template="plotly_white",
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)
fig.update_traces(texttemplate="%{text:.0f}%", textposition="outside")

fig.update_xaxes(showline=True, linewidth=1, linecolor="white", range=[0, 55], showgrid=False)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/ht.svg",
    "https://flagicons.lipis.dev/flags/4x3/kp.svg",
    "https://flagicons.lipis.dev/flags/4x3/mg.svg",
    "https://flagicons.lipis.dev/flags/4x3/lr.svg",
    "https://flagicons.lipis.dev/flags/4x3/ls.svg",
    "https://flagicons.lipis.dev/flags/4x3/td.svg",
    "https://flagicons.lipis.dev/flags/4x3/rw.svg",
    "https://flagicons.lipis.dev/flags/4x3/mz.svg",
    "https://flagicons.lipis.dev/flags/4x3/tl.svg",
    "https://flagicons.lipis.dev/flags/4x3/af.svg"
]

# Positions of the images
proportions = top_10_countries['Proportion'].tolist()
positions = [(proportions-3, i - 0.5) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=3,
            sizey=3,
            layer="above",
        )
    )

# Show the figure
fig.show()
fig.write_image("src/main/extracted_data/6.svg")

#population_sous_nutrition.sort_values(by='Sous_nutrition', ascending=False).head(10)

#Pays qui ont le plus bénéficié d'aide alimentaire depuis 2013
#calcul du total de l'aide alimentaire par pays
aide_alimentaire_total = aide_alimentaire.groupby('Zone')['Valeur'].sum().reset_index()

#affichage après trie des 10 pays qui ont bénéficié le plus de l'aide alimentaire
aide_alimentaire_total.sort_values(by='Valeur', ascending=False).head(10).style.format({'Valeur': "{:,}"})

aide_alimentaire_total = aide_alimentaire_total.sort_values(
    by="Valeur", ascending=False
).head(10)
aide_alimentaire_total['Valeur_in_billion'] = aide_alimentaire_total['Valeur'] / 1_000_000_000

# Create the bar chart using Plotly
fig = px.bar(
    aide_alimentaire_total,
    x="Valeur",
    y="Zone",
    orientation="h",
    title="Top 10 Countries with Highest Amount of Aid Received Since 2013-2016",
    labels={"Valeur": "Aid Received", "Zone": "Country"},
    text="Valeur",
    custom_data="Valeur_in_billion",
    color="Valeur",
    # color_continuous_scale="Blues",
    color_continuous_scale=["rgb(229,229,255)", "rgb(0,0,255)"]
)

# Update the layout to invert the y-axis and remove x-axis title and color bar
fig.update_layout(
    yaxis=dict(autorange="reversed", title=None),
    xaxis_title="Aid Received (€)",
    coloraxis_showscale=False,
    width=1200,
    height=500,
    template="plotly_white",
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

fig.update_traces(texttemplate="€%{customdata[0]:.2f}B", textposition="outside")

fig.update_xaxes(showline=True, linewidth=1, linecolor="white", range=[0, 2_000_000_000], showgrid=False)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/sy.svg",
    "https://flagicons.lipis.dev/flags/4x3/et.svg",
    "https://flagicons.lipis.dev/flags/4x3/ye.svg",
    "https://flagicons.lipis.dev/flags/4x3/ss.svg",
    "https://flagicons.lipis.dev/flags/4x3/sd.svg",
    "https://flagicons.lipis.dev/flags/4x3/ke.svg",
    "https://flagicons.lipis.dev/flags/4x3/bd.svg",
    "https://flagicons.lipis.dev/flags/4x3/so.svg",
    "https://flagicons.lipis.dev/flags/4x3/cg.svg",
    "https://flagicons.lipis.dev/flags/4x3/ne.svg"
]

# Positions of the images
proportions = aide_alimentaire_total['Valeur'].tolist()
positions = [(proportions-100_000_000, i - 0.5) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=100_000_000,
            sizey=100_000_000,
            layer="above",
        )
    )

# Show the figure
fig.show()
fig.write_image("src/main/extracted_data/7.svg")

aide_alimentaire["Année"].unique()

#Evolution des 5 pays qui ont le plus bénéficiés de l'aide alimentaire entre 2013 et 2016
#Création d'un dataframe avec la zone, l'année et l'aide alimentaire puis groupby sur zone et année 
aide_alimentaire_zone = aide_alimentaire.groupby(['Zone', 'Année'])['Valeur'].sum().reset_index()

#Création d'une liste contenant les 5 pays qui ont le plus bénéficiées de l'aide alimentaire
top_5_aide_alimentaire = aide_alimentaire_total.sort_values(by='Valeur', ascending=False).head(5)['Zone'].tolist()

#On filtre sur le dataframe avec notre liste
aide_alimentaire_zone = aide_alimentaire_zone[aide_alimentaire_zone['Zone'].isin(top_5_aide_alimentaire)]

# Affichage des pays avec l'aide alimentaire par année
aide_alimentaire_zone.style.format({'Valeur': "{:,}"})

# Assuming pivot_df is the DataFrame after pivot
pivot_df = aide_alimentaire_zone.pivot(index="Année", columns="Zone", values="Valeur")

title = "Aid Received Over Time"
labels = pivot_df.columns.tolist()
colors = [
    "rgb(163,163,163)", # syrie
    "rgb(163,163,163)", # soudan
    "rgb(163,163,163)", # sudan du sud
    "rgb(0,0,255)", # yemen
    "rgb(163,163,163)", # ethiopia
]

mode_size = [8, 8, 8, 12, 8]
line_size = [2, 2, 2, 4, 2]

x_data = pivot_df.index

fig = go.Figure()

# Add a trace for each zone
for i, zone in enumerate(labels):
    y_data = pivot_df[zone].values
    fig.add_trace(
        go.Scatter(
            x=x_data,
            y=y_data,
            mode="lines",
            name=zone,
            line=dict(
                color=colors[i % len(colors)], width=line_size[i % len(line_size)]
            ),
            connectgaps=True,
        )
    )

# Endpoints
for i, zone in enumerate(labels):
    y_data = pivot_df[zone].values

    # Find the last valid index
    last_valid_index = len(y_data) - 1
    while last_valid_index >= 0 and pd.isna(y_data[last_valid_index]):
        last_valid_index -= 1

    # Add a marker at the last valid index
    if last_valid_index >= 0:
        fig.add_trace(
            go.Scatter(
                x=[x_data[0], x_data[last_valid_index]],
                y=[y_data[0], y_data[last_valid_index]],
                mode="markers",
                marker=dict(
                    color=colors[i % len(colors)], size=mode_size[i % len(mode_size)]
                ),
            )
        )

fig.update_layout(
    xaxis=dict(
        showline=True,
        showgrid=False,
        showticklabels=True,
        linecolor="rgb(204, 204, 204)",
        linewidth=2,
        ticks="outside",
        tickfont=dict(
            family="Arial",
            size=14,
            color="white",
        ),
        tickvals=[2013, 2014, 2015, 2016],
    ),
    yaxis=dict(
        showgrid=False,
        zeroline=False,
        showline=False,
        showticklabels=False,
    ),
    autosize=False,
    margin=dict(
        autoexpand=False,
        l=200,
        r=20,
        t=110,
    ),
    showlegend=False,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

annotations = []

# Adding labels
for i, zone in enumerate(labels):
    y_data = pivot_df[zone].values
    color = colors[i % len(colors)]
    # Labeling the left side of the plot
    annotations.append(
        dict(
            xref="paper",
            x=0.05,
            y=y_data[0],
            xanchor="right",
            yanchor="middle",
            text=zone + " {}M".format(int(y_data[0] / 1_000_000)),
            font=dict(family="Arial", size=16, color="white"),
            showarrow=False,
        )
    )

    # Find the last valid index
    last_valid_index = len(y_data) - 1
    while last_valid_index >= 0 and pd.isna(y_data[last_valid_index]):
        last_valid_index -= 1

    # Labeling the right side of the plot at the last valid index
    if last_valid_index >= 0:
        annotations.append(
            dict(
                xref="x",
                x=x_data[last_valid_index],
                y=y_data[last_valid_index],
                xanchor="left",
                yanchor="middle",
                text="{}M".format(int(y_data[last_valid_index] / 1_000_000)),
                font=dict(family="Arial", size=16, color="white"),
                showarrow=False,
            )
        )

# Title
annotations.append(
    dict(
        xref="paper",
        yref="paper",
        x=0.0,
        y=1.05,
        xanchor="left",
        yanchor="bottom",
        text=title,
        font=dict(family="Arial", size=30, color="white"),
        showarrow=False,
    )
)

fig.update_layout(annotations=annotations, width=1500, height=600)

fig.show()
fig.write_image("src/main/extracted_data/8.svg")

#Calcul de la disponibilité en kcal par personne par jour par pays
dispo_alimentaire_par_pays = dispo_alimentaire.groupby('Zone')['Disponibilité alimentaire (Kcal/personne/jour)'].sum().reset_index()

#Affichage des 10 pays qui ont le moins de dispo alimentaire par personne 
dispo_alimentaire_par_pays.sort_values(by='Disponibilité alimentaire (Kcal/personne/jour)').head(10)

# Group and sort the data
dispo_alimentaire_par_pays = dispo_alimentaire.groupby('Zone')['Disponibilité alimentaire (Kcal/personne/jour)'].sum().reset_index()
dispo_alimentaire_par_pays = dispo_alimentaire_par_pays.sort_values(by='Disponibilité alimentaire (Kcal/personne/jour)', ascending=True).head(10)
dispo_alimentaire_par_pays.set_index('Zone', inplace=True)

# Create the Plotly bar chart
fig = go.Figure(go.Bar(
    x=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)'],
    y=dispo_alimentaire_par_pays.index,
    orientation='h',
    marker=dict(
        color=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)'],
        colorscale='Reds',  # Change to a continuous color scale
        reversescale=True,  # Add this line to reverse the color scale
        # colorbar=dict(
        #     title='Kcal/personne/jour',
        #     tickvals=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)']
        # )
    ),
    text=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)']
))

fig.update_layout(
    title='Top 10 Pays avec le moins de disponibilité par habitant',
    xaxis_title='Disponibilité alimentaire (Kcal/personne/jour)',
    yaxis_title='',
    # xaxis=dict(type='log'), 
    yaxis=dict(autorange='reversed'),  # Invert the y-axis to display the country with the highest number at the top
    template='plotly_white',
    width= 1500,
    height= 600,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/cf.svg",
    "https://flagicons.lipis.dev/flags/4x3/zm.svg",
    "https://flagicons.lipis.dev/flags/4x3/mg.svg",
    "https://flagicons.lipis.dev/flags/4x3/af.svg",
    "https://flagicons.lipis.dev/flags/4x3/ht.svg",
    "https://flagicons.lipis.dev/flags/4x3/kp.svg",
    "https://flagicons.lipis.dev/flags/4x3/td.svg",
    "https://flagicons.lipis.dev/flags/4x3/zw.svg",
    "https://flagicons.lipis.dev/flags/4x3/ug.svg",
    "https://flagicons.lipis.dev/flags/4x3/tl.svg"
]

# Positions of the images
proportions = dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)'].tolist()
positions = [(proportions-100, i-0.43) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=100,
            sizey=100,
            layer="above",
        )
    )

# Format the text to be displayed directly on the bars
fig.update_traces(texttemplate='%{text:,.0f}', textposition='outside')
fig.update_xaxes(showline=True, linewidth=1, linecolor="white", showgrid=False)

fig.show()
fig.write_image("src/main/extracted_data/9.svg")

#Affichage des 10 pays qui ont le plus de dispo alimentaire par personne 
dispo_alimentaire_par_pays.sort_values(by='Disponibilité alimentaire (Kcal/personne/jour)', ascending=False).head(10)

# Group and sort the data
dispo_alimentaire_par_pays = dispo_alimentaire.groupby('Zone')['Disponibilité alimentaire (Kcal/personne/jour)'].sum().reset_index()
dispo_alimentaire_par_pays = dispo_alimentaire_par_pays.sort_values(by='Disponibilité alimentaire (Kcal/personne/jour)', ascending=False).head(10)
dispo_alimentaire_par_pays.set_index('Zone', inplace=True)

# Create the Plotly bar chart
fig = go.Figure(go.Bar(
    x=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)'],
    y=dispo_alimentaire_par_pays.index,
    orientation='h',
    marker=dict(
        color=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)'],
        # colorscale='Blues',  # Change to a continuous color scale
        colorscale=["rgb(229,229,255)", "rgb(0,0,255)"]
        # reversescale=True,  # Add this line to reverse the color scale
        # colorbar=dict(
        #     title='Kcal/personne/jour',
        #     tickvals=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)']
        # )
    ),
    text=dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)'],

))

fig.update_layout(
    title='Top 10 Pays avec le plus de disponibilité par habitant',
    xaxis_title='Disponibilité alimentaire (Kcal/personne/jour)',
    yaxis_title='',
    yaxis=dict(autorange='reversed'),  # Invert the y-axis to display the country with the highest number at the top
    template='plotly_white',
    width= 1500,
    height= 600,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/at.svg",
    "https://flagicons.lipis.dev/flags/4x3/be.svg",
    "https://flagicons.lipis.dev/flags/4x3/tr.svg",
    "https://flagicons.lipis.dev/flags/4x3/us.svg",
    "https://flagicons.lipis.dev/flags/4x3/il.svg",
    "https://flagicons.lipis.dev/flags/4x3/ie.svg",
    "https://flagicons.lipis.dev/flags/4x3/it.svg",
    "https://flagicons.lipis.dev/flags/4x3/lu.svg",
    "https://flagicons.lipis.dev/flags/4x3/eg.svg",
    "https://flagicons.lipis.dev/flags/4x3/de.svg"
]

# Positions of the images
proportions = dispo_alimentaire_par_pays['Disponibilité alimentaire (Kcal/personne/jour)'].tolist()
positions = [(proportions-150, i-0.43) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=150,
            sizey=150,
            layer="above",
        )
    )

# Format the text to be displayed directly on the bars
fig.update_traces(texttemplate='%{text:,.0f}', textposition='outside')
fig.update_xaxes(showline=True, linewidth=1, linecolor="white", showgrid=False)

fig.show()
fig.write_image("src/main/extracted_data/10.svg")

#Exemple de la Thaïlande pour le Manioc
#création d'un dataframe avec uniquement la Thaïlande 
dispo_alimentaire_thailande = dispo_alimentaire[dispo_alimentaire['Zone'] == 'Thaïlande']

#Calcul de la sous nutrition en Thaïlande
sous_nutrition_thailande = sous_nutrition_2017[sous_nutrition_2017['Zone'] == 'Thaïlande']
print(sous_nutrition_thailande)

# Calculate the sum of 'Population' and 'Sous_nutrition'
sous_nutrition_thailande_sum = sous_nutrition_thailande["Sous_nutrition"].sum()
population_thailande = population_2017[population_2017['Zone'] == 'Thaïlande']['Population'].sum()
# Calculate the rates
sous_nutrition_rate = sous_nutrition_thailande_sum / population_thailande * 100
sufficient_nutrition_rate = 100 - sous_nutrition_rate

# Create a new DataFrame for the pie chart
df_pie = pd.DataFrame(
    {
        "Nutrition": ["Undernourished", "Sufficient"],
        "Rate": [sous_nutrition_rate, sufficient_nutrition_rate],
    }
)

# Create the pie chart
fig = px.pie(
    df_pie,
    values="Rate",
    names="Nutrition",
    title="Thailande Nutrition Status in 2017",
    hole=0.3,
    color_discrete_sequence=["blue", "red"],
)
fig.update_traces(textinfo="percent+label", pull=[0.1, 0], rotation=105)
fig.update_layout(
    width=800,
    height=600,
    annotations=[dict(text="Total Pop:<br> 69 Million", showarrow=False)],
    showlegend=False,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

fig.show()
fig.write_image("src/main/extracted_data/11.svg")

# On calcule la proportion exportée en fonction de la proportion
# disponible intérieurement pour chaque produit
dispo_alimentaire_thailande['Exportation (%)'] = dispo_alimentaire_thailande['Exportations - Quantité'] / dispo_alimentaire_thailande['Production'] * 100
dispo_alimentaire_thailande[dispo_alimentaire_thailande["Produit"] == "Manioc"]

# Filter the data for the product "Manioc"
manioc_data = dispo_alimentaire_thailande[
    dispo_alimentaire_thailande["Produit"] == "Manioc"
]

# Calculate exportation and consumption proportions
exportation = manioc_data["Exportation (%)"].mean() / 100
consumption = 1 - exportation
total_manioc_prod = manioc_data["Production"].mean()

# Create a pie chart
fig = go.Figure(
    data=[
        go.Pie(
            labels=["Exportation", "Consumption"],
            values=[exportation, consumption],
            hole=0.3,
            marker=dict(colors=["Green", "gray"]),
        )
    ]
)
fig.update_traces(textinfo="percent+label",  pull=[0, 0.1], rotation=-55)
fig.update_layout(
    title_text="Exportation of Manioc in Thailand",
    width=800,
    height=600,
    showlegend=False,
    annotations=[
        dict(
            text=f"Total Manioc:<br>{total_manioc_prod/1_000_000_000:,.0f} Billion kg",
            showarrow=False,
        )
    ],
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=16),
)
fig.show()
fig.write_image("src/main/extracted_data/12.svg")

manioc_export = dispo_alimentaire_thailande[dispo_alimentaire_thailande["Produit"] == "Manioc"]['Exportations - Quantité'].sum() 
manioc_export_feed = manioc_export * 1250 / (2250 * 365)
print("{:,.2f} million".format(manioc_export_feed))

# Data
sous_nutrition_thailande_sum
capacity = manioc_export_feed
sous_nutrition_thailande_percent = 100
capacity_percent = capacity / sous_nutrition_thailande_sum * 100

# Create a bar chart using Plotly
fig = go.Figure(
    data=[
        go.Bar(
            name="Population",
            x=["Population"],
            y=[sous_nutrition_thailande_sum],
            marker_color="red",
            text=[f"{sous_nutrition_thailande_percent:.0f}%"],
            textposition="outside",
        ),
        go.Bar(
            name="Capacity",
            x=["Capacity"],
            y=[capacity],
            marker_color="green",
            text=[f"{capacity_percent:.0f}%"],
            textposition="outside",
        ),
    ]
)

# Update the layout
fig.update_layout(
    title="Under Nurrished Population vs Feeding Capacity by Manioc in Thailand",
    yaxis_title="Population",
    barmode="group",
    showlegend=False,
    width=800,
    height=600,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# Add annotations one by one
fig.add_annotation(
    x="Population",
    y=sous_nutrition_thailande_sum / 2,
    text=f"{sous_nutrition_thailande_sum/1_000_000:.1f} Million",
    showarrow=False,
    font=dict(color="white", size=30),
)

fig.add_annotation(
    x="Capacity",
    y=capacity / 2,
    text=f"{capacity/1_000_000:.1f} Million",
    showarrow=False,
    font=dict(color="white", size=30),
)

# Show the figure
fig.show()
fig.write_image("src/main/extracted_data/13.svg")

columns_to_sum = ['Exportations - Quantité', 'Importations - Quantité', 'Production']
dispo_alimentaire.groupby('Zone')[columns_to_sum].sum().sort_values(by='Production', ascending=False).head(10)

# Group and sort the data
top_production = dispo_alimentaire.groupby('Zone')[columns_to_sum].sum().sort_values(by='Production', ascending=False).head(10)
# top_production.set_index('Zone', inplace=True)

# Create the Plotly bar chart
fig = go.Figure(go.Bar(
    x=top_production['Production'],
    y=top_production.index,
    orientation='h',
    marker=dict(
        color=top_production['Production'],
        # colorscale='Blues',  # Change to a continuous color scale
        colorscale=["rgb(229,229,255)", "rgb(0,0,255)"]
        # reversescale=True,  # Add this line to reverse the color scale
        # colorbar=dict(
        #     title='Kcal/personne/jour',
        #     tickvals=top_production['Production']
        # )
    ),
    text=top_production['Production'] / 1_000_000_000_000,

))

fig.update_layout(
    title='Top 10 Pays avec le plus de Production',
    xaxis_title='Production (€)',
    yaxis_title='',
    yaxis=dict(autorange='reversed'),  # Invert the y-axis to display the country with the highest number at the top
    template='plotly_white',
    width= 1500,
    height= 700,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/cn.svg",
    "https://flagicons.lipis.dev/flags/4x3/br.svg",
    "https://flagicons.lipis.dev/flags/4x3/in.svg",
    "https://flagicons.lipis.dev/flags/4x3/us.svg",
    "https://flagicons.lipis.dev/flags/4x3/ru.svg",
    "https://flagicons.lipis.dev/flags/4x3/id.svg",
    "https://flagicons.lipis.dev/flags/4x3/th.svg",
    "https://flagicons.lipis.dev/flags/4x3/ng.svg",
    "https://flagicons.lipis.dev/flags/4x3/fr.svg",
    "https://flagicons.lipis.dev/flags/4x3/ar.svg"
]

# Positions of the images
proportions = top_production['Production'].tolist()
positions = [(proportions-100_000_000_000, i-0.43) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=100_000_000_000,
            sizey=100_000_000_000,
            layer="above",
        )
    )

# Format the text to be displayed directly on the bars
fig.update_traces(texttemplate='€%{text:,.2f}T', textposition='outside')
fig.update_xaxes(showline=True, linewidth=1, linecolor="white", showgrid=False)

fig.show()
fig.write_image("src/main/extracted_data/14.svg")

# Group and sort the data
least_production = dispo_alimentaire.groupby('Zone')[columns_to_sum].sum().sort_values(by='Production', ascending=True).head(10)
# least_production.set_index('Zone', inplace=True)

# Create the Plotly bar chart
fig = go.Figure(go.Bar(
    x=least_production['Production'],
    y=least_production.index,
    orientation='h',
    marker=dict(
        color=least_production['Production'],
        colorscale='Reds',  # Change to a continuous color scale
        # colorscale=["rgb(229,229,255)", "rgb(0,0,255)"]
        # reversescale=True,  # Add this line to reverse the color scale
        # colorbar=dict(
        #     title='Kcal/personne/jour',
        #     tickvals=least_production['Production']
        # )
    ),
    text=least_production['Production'] / 1_000_000,

))

fig.update_layout(
    title='Top 10 Pays avec the least de Production',
    xaxis_title='Production (€)',
    yaxis_title='',
    yaxis=dict(autorange='reversed'),  # Invert the y-axis to display the country with the highest number at the top
    template='plotly_white',
    width= 1500,
    height= 700,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/bm.svg",
    "https://flagicons.lipis.dev/flags/4x3/mo.svg",
    "https://flagicons.lipis.dev/flags/4x3/ag.svg",
    "https://flagicons.lipis.dev/flags/4x3/kn.svg",
    "https://flagicons.lipis.dev/flags/4x3/gd.svg",
    "https://flagicons.lipis.dev/flags/4x3/bn.svg",
    "https://flagicons.lipis.dev/flags/4x3/lc.svg",
    "https://flagicons.lipis.dev/flags/4x3/dj.svg",
    "https://flagicons.lipis.dev/flags/4x3/nc.svg",
    "https://flagicons.lipis.dev/flags/4x3/dm.svg"
]

# Positions of the images
proportions = least_production['Production'].tolist()
positions = [(proportions-6_000_000, i-0.43) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=6_000_000,
            sizey=6_000_000,
            layer="above",
        )
    )

# Format the text to be displayed directly on the bars
fig.update_traces(texttemplate='€%{text:,.0f}M', textposition='outside')
fig.update_xaxes(showline=True, linewidth=1, linecolor="white", showgrid=False)

fig.show()
fig.write_image("src/main/extracted_data/15.svg")

# Group and sort the data
top_export = dispo_alimentaire.groupby('Zone')[columns_to_sum].sum().sort_values(by='Exportations - Quantité', ascending=False).head(10)
# top_export.set_index('Zone', inplace=True)

# Create the Plotly bar chart
fig = go.Figure(go.Bar(
    x=top_export['Exportations - Quantité'],
    y=top_export.index,
    orientation='h',
    marker=dict(
        color=top_export['Exportations - Quantité'],
        # colorscale='Blues',  # Change to a continuous color scale
        colorscale=["rgb(145,240,134)", "rgb(2,35,28)"]
        # reversescale=True,  # Add this line to reverse the color scale
        # colorbar=dict(
        #     title='Kcal/personne/jour',
        #     tickvals=top_export['Exportations - Quantité']
        # )
    ),
    text=top_export['Exportations - Quantité'] / 1_000_000_000,

))

fig.update_layout(
    title='Top 10 Pays avec le plus de Exportations - Quantité',
    xaxis_title='Exportations - Quantité',
    yaxis_title='',
    yaxis=dict(autorange='reversed'),  # Invert the y-axis to display the country with the highest number at the top
    template='plotly_white',
    width= 1500,
    height= 800,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/us.svg",
    "https://flagicons.lipis.dev/flags/4x3/br.svg",
    "https://flagicons.lipis.dev/flags/4x3/fr.svg",
    "https://flagicons.lipis.dev/flags/4x3/de.svg",
    "https://flagicons.lipis.dev/flags/4x3/ca.svg",
    "https://flagicons.lipis.dev/flags/4x3/ar.svg",
    "https://flagicons.lipis.dev/flags/4x3/nl.svg",
    "https://flagicons.lipis.dev/flags/4x3/th.svg",
    "https://flagicons.lipis.dev/flags/4x3/au.svg",
    "https://flagicons.lipis.dev/flags/4x3/in.svg"
]

# Positions of the images
proportions = top_export['Exportations - Quantité'].tolist()
positions = [(proportions-10_000_000_000, i-0.43) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=10_000_000_000,
            sizey=10_000_000_000,
            layer="above",
        )
    )

# Format the text to be displayed directly on the bars
fig.update_traces(texttemplate='%{text:,.2f}B', textposition='outside')
fig.update_xaxes(showline=True, linewidth=1, linecolor="white", showgrid=False)

fig.show()
fig.write_image("src/main/extracted_data/16.svg")

# Group and sort the data
top_import = dispo_alimentaire.groupby('Zone')[columns_to_sum].sum().sort_values(by='Importations - Quantité', ascending=False).head(10)
# top_import.set_index('Zone', inplace=True)

# Create the Plotly bar chart
fig = go.Figure(go.Bar(
    x=top_import['Importations - Quantité'],
    y=top_import.index,
    orientation='h',
    marker=dict(
        color=top_import['Importations - Quantité'],
        colorscale='ylorbr',  # Change to a continuous color scale
        # colorscale=["rgb(145,240,134)", "rgb(2,35,28)"]
        # reversescale=True,  # Add this line to reverse the color scale
        # colorbar=dict(
        #     title='Kcal/personne/jour',
        #     tickvals=top_import['Importations - Quantité']
        # )
    ),
    text=top_import['Importations - Quantité'] / 1_000_000_000,

))

fig.update_layout(
    title='Top 10 Pays avec le plus de Importations - Quantité',
    xaxis_title='Importations - Quantité',
    yaxis_title='',
    yaxis=dict(autorange='reversed'),  # Invert the y-axis to display the country with the highest number at the top
    template='plotly_white',
    width= 1500,
    height= 800,
    paper_bgcolor="rgba(0,0,0,0)",  # make the paper background transparent
    plot_bgcolor="rgba(0,0,0,0)",  # make the plot background transparent
    font=dict(color="white", size=14),
)

# URLs of the images
image_urls = [
    "https://flagicons.lipis.dev/flags/4x3/cn.svg",
    "https://flagicons.lipis.dev/flags/4x3/us.svg",
    "https://flagicons.lipis.dev/flags/4x3/de.svg",
    "https://flagicons.lipis.dev/flags/4x3/jp.svg",
    "https://flagicons.lipis.dev/flags/4x3/nl.svg",
    "https://flagicons.lipis.dev/flags/4x3/it.svg",
    "https://flagicons.lipis.dev/flags/4x3/be.svg",
    "https://flagicons.lipis.dev/flags/4x3/fr.svg",
    "https://flagicons.lipis.dev/flags/4x3/es.svg",
    "https://flagicons.lipis.dev/flags/4x3/mx.svg"
]

# Positions of the images
proportions = top_import['Importations - Quantité'].tolist()
positions = [(proportions-10_000_000_000, i-0.45) for i, proportions in enumerate(proportions)]

for url, (x, y) in zip(image_urls, positions):
    fig.add_layout_image(
        dict(
            source=url,
            xref="x",
            yref="y",
            x=x,
            y=y,
            sizex=10_000_000_000,
            sizey=10_000_000_000,
            layer="above",
        )
    )

# Format the text to be displayed directly on the bars
fig.update_traces(texttemplate='%{text:,.2f}B', textposition='outside')
fig.update_xaxes(showline=True, linewidth=1, linecolor="white", showgrid=False)

fig.show()
fig.write_image("src/main/extracted_data/17.svg")